Run out of time for tonight, but I did wonder what an example use case for slerping rotation and magnitude is? It's not something that occurred to me. Is that something Unity and Godot implementations do also?

There is some extra cost incurred if we can't assume that the input vectors are length zero and they behave differently to the Quat methods of the same name given we expect Quat to be unit length. Which isn't to say that scale shouldn't be handled, but possibly it is worth having versions that slerp or rotate with and without scale and the scale version is named differently from the Quat methods.

Ran out of time for tonight

Take your time! I'm not in a hurry - even if it may seem that way, haha

Is that something Unity and Godot implementations do also?

Yes, both Unity and Godot interpolate the magnitude in their vector slerp implementations - which does make sense for a lerp in spherical coordinates -, and for the quat slerp implementation they require quaternions to be unit length, like ours.

Unity docs: vector slerp, quat slerp
Godot docs: vector slerp, quat slerp

Unity's and Godot's implementations are likely the most well known implementations - very likely for Bevy's userbase -, and it still handles unit vectors as anyone would expect which makes me think calling this slerp is the right move.

This does run about 25%~ slower compared to the slerp method that assumes the inputs are unit vectors that I have locally. Which is a good reason to have a method - slerp_unit perhaps? - to reach for when the user knows they're only dealing with unit vectors in a hot loop

I haven't had time to put much more thought into this, I did notice that Unreal doesn't have a method that slerps rotation and magnitude, it just has https://dev.epicgames.com/documentation/en-us/unreal-engine/API/Runtime/Core/Math/TVector/SlerpNormals and https://dev.epicgames.com/documentation/en-us/unreal-engine/API/Runtime/Core/Math/TVector/SlerpVectorToDirection (which maintains the magnitude of the input vector).

I would almost be inclined to only add slerp_normals, lerping magnitude in slerp seems like it would be fairly niche, but it could be added if someone wanted that specific functionality.

I did think of one example where lerping the length might be useful, which is sometimes when dealing with velocity vectors it could be desirable to slerp towards a target velocity. Still, this feels a bit less common to me so I feel like offering a method that just slerps normals would be desirable as well, so people don't need to pay the cost of dealing with length if they don't need it.

Decided to take this as is, slerp_normals could be added later.